/**
 * Chrome Extension API 统一封装
 * 提供类型安全的Chrome API调用，便于维护和测试
 * 符合Chrome MV3规范，避免使用废弃的API
 */
import {isSystemOrExtensionUrl} from "@/lib/utils.ts";

// 标签页相关API封装
export const chromeTabs = {
    /**
     * 查询符合条件的标签页
     * @param queryInfo 查询条件
     * @returns 符合条件的标签页数组
     */
    async query(queryInfo: chrome.tabs.QueryInfo): Promise<chrome.tabs.Tab[]> {
        try {
            return await chrome.tabs.query(queryInfo);
        } catch (error) {
            console.error('查询标签页失败:', error);
            throw error;
        }
    },

    /**
     * 创建新的标签页
     * @param createProperties 创建标签页的属性
     * @returns 创建的标签页对象
     */
    async create(createProperties: chrome.tabs.CreateProperties): Promise<chrome.tabs.Tab> {
        try {
            return await chrome.tabs.create(createProperties);
        } catch (error) {
            console.error('创建标签页失败:', error);
            throw error;
        }
    },

    /**
     * 更新指定标签页
     * @param tabId 标签页ID
     * @param updateProperties 更新的属性
     * @returns 更新后的标签页对象
     */
    async update(tabId: number, updateProperties: chrome.tabs.UpdateProperties): Promise<chrome.tabs.Tab> {
        try {
            return await chrome.tabs.update(tabId, updateProperties);
        } catch (error) {
            console.error('更新标签页失败:', error);
            throw error;
        }
    },

    /**
     * 关闭指定的标签页
     * @param tabIds 要关闭的标签页ID数组
     */
    async remove(tabIds: number | number[]): Promise<void> {
        try {
            await chrome.tabs.remove(tabIds);
        } catch (error) {
            console.error('关闭标签页失败:', error);
            throw error;
        }
    },
};

// 窗口相关API封装
export const chromeWindows = {
    /**
     * 获取当前窗口
     * @returns 当前窗口对象
     */
    async getCurrent(): Promise<chrome.windows.Window> {
        try {
            return await chrome.windows.getCurrent();
        } catch (error) {
            console.error('获取当前窗口失败:', error);
            throw error;
        }
    },

    /**
     * 创建新窗口
     * @param createData 创建窗口的参数
     * @returns 创建的窗口对象
     */
    async create(createData: chrome.windows.CreateData): Promise<chrome.windows.Window> {
        try {
            return await chrome.windows.create(createData);
        } catch (error) {
            console.error('创建窗口失败:', error);
            throw error;
        }
    },

    /**
     * 更新窗口属性
     * @param windowId 窗口ID
     * @param updateInfo 更新信息
     * @returns 更新后的窗口对象
     */
    async update(windowId: number, updateInfo: chrome.windows.UpdateInfo): Promise<chrome.windows.Window> {
        try {
            return await chrome.windows.update(windowId, updateInfo);
        } catch (error) {
            console.error('更新窗口失败:', error);
            throw error;
        }
    },
};

// Runtime相关API封装
export const chromeRuntime = {
    /**
     * 获取扩展内部URL
     * @param path 资源路径
     * @returns 完整的扩展URL
     */
    getURL(path: string): string {
        try {
            return chrome.runtime.getURL(path);
        } catch (error) {
            console.error('获取扩展URL失败:', error);
            throw error;
        }
    },

    /**
     * 获取扩展manifest信息
     * @returns manifest对象
     */
    getManifest(): chrome.runtime.Manifest {
        try {
            return chrome.runtime.getManifest();
        } catch (error) {
            console.error('获取manifest失败:', error);
            throw error;
        }
    },

    /**
     * 发送消息到Background Script
     * @param message 消息对象
     * @returns 响应Promise
     */
    async sendMessage(message: any): Promise<any> {
        try {
            return await chrome.runtime.sendMessage(message);
        } catch (error) {
            console.error('发送消息失败:', error);
            throw error;
        }
    },
};

// 组合操作：常用的高级API
export const chromeActions = {
    /**
     * 获取当前窗口的所有标签页
     * @returns 当前窗口的标签页数组
     */
    async getCurrentWindowTabs(): Promise<chrome.tabs.Tab[]> {
        return await chromeTabs.query({currentWindow: true});
    },

    /**
     * 检查当前窗口是否只包含最少的非系统标签页
     * @param maxNonSystemTabs 非系统标签页的最大数量阈值，默认为1
     * @returns 如果是最小化窗口返回true
     */
    async isCurrentWindowMinimal(maxNonSystemTabs: number = 1): Promise<boolean> {
        // 获取当前窗口的所有标签页
        const tabs = await chromeTabs.query({currentWindow: true});

        // 过滤掉系统页面和扩展页面，看还剩什么
        const nonSystemTabs = tabs.filter((tab) => {
            if (!tab.url || tab.pinned) return false;
            // 使用统一的系统页面判断函数
            return !isSystemOrExtensionUrl(tab.url);
        });

        // 如果只剩下很少的非系统标签页，认为是最小化窗口
        return nonSystemTabs.length <= maxNonSystemTabs;
    },

    /**
     * 保存集合后的标签页管理 - 通过Background Script执行
     * 避免当前页面关闭导致的逻辑中断问题
     * @param nonPinnedTabIds 需要关闭的非固定标签页ID列表
     * @param pinnedTabsCount 固定标签页数量
     * @returns 处理结果
     */
    async saveCollectionAndManageTabs(
        nonPinnedTabIds: number[],
        pinnedTabsCount: number
    ): Promise<{ success: boolean; message?: string; error?: string }> {
        try {
            const response = await chromeRuntime.sendMessage({
                type: 'SAVE_COLLECTION_AND_MANAGE_TABS',
                data: {
                    nonPinnedTabIds,
                    pinnedTabsCount
                }
            });

            if (!response?.success) {
                throw new Error(response?.error || 'Background Script处理失败');
            }

            return { success: true, message: response.result?.message };
        } catch (error) {
            console.warn('Background Script标签页管理失败，尝试降级处理:', error);

            // 降级处理：如果Background Script失败，至少尝试关闭标签页
            if (nonPinnedTabIds.length > 0) {
                try {
                    await chromeTabs.remove(nonPinnedTabIds);
                    console.debug('降级处理：已关闭标签页');
                    return { success: true, message: '降级处理：已关闭标签页' };
                } catch (removeError) {
                    console.warn('降级处理也失败:', removeError);
                    return {
                        success: false,
                        error: `Background Script和降级处理都失败: ${error instanceof Error ? error.message : String(error)}`
                    };
                }
            }

            return {
                success: false,
                error: error instanceof Error ? error.message : String(error)
            };
        }
    },
};
